home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / gfx / conv / jpegV5Asrc.lha / jpeg-5a / jmemdos.c < prev    next >
C/C++ Source or Header  |  1994-04-01  |  19KB  |  635 lines
  1. /*
  2.  * jmemdos.c
  3.  *
  4.  * Copyright (C) 1992-1994, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file provides an MS-DOS-compatible implementation of the system-
  9.  * dependent portion of the JPEG memory manager.  Temporary data can be
  10.  * stored in extended or expanded memory as well as in regular DOS files.
  11.  *
  12.  * If you use this file, you must be sure that NEED_FAR_POINTERS is defined
  13.  * if you compile in a small-data memory model; it should NOT be defined if
  14.  * you use a large-data memory model.  This file is not recommended if you
  15.  * are using a flat-memory-space 386 environment such as DJGCC or Watcom C.
  16.  * Also, this code will NOT work if struct fields are aligned on greater than
  17.  * 2-byte boundaries.
  18.  *
  19.  * Based on code contributed by Ge' Weijers.
  20.  */
  21.  
  22. /*
  23.  * If you have both extended and expanded memory, you may want to change the
  24.  * order in which they are tried in jopen_backing_store.  On a 286 machine
  25.  * expanded memory is usually faster, since extended memory access involves
  26.  * an expensive protected-mode-and-back switch.  On 386 and better, extended
  27.  * memory is usually faster.  As distributed, the code tries extended memory
  28.  * first (what? not everyone has a 386? :-).
  29.  *
  30.  * You can disable use of extended/expanded memory entirely by altering these
  31.  * definitions or overriding them from the Makefile (eg, -DEMS_SUPPORTED=0).
  32.  */
  33.  
  34. #ifndef XMS_SUPPORTED
  35. #define XMS_SUPPORTED  1
  36. #endif
  37. #ifndef EMS_SUPPORTED
  38. #define EMS_SUPPORTED  1
  39. #endif
  40.  
  41.  
  42. #define JPEG_INTERNALS
  43. #include "jinclude.h"
  44. #include "jpeglib.h"
  45. #include "jmemsys.h"        /* import the system-dependent declarations */
  46.  
  47. #ifndef HAVE_STDLIB_H        /* <stdlib.h> should declare these */
  48. extern void * malloc JPP((size_t size));
  49. extern void free JPP((void *ptr));
  50. extern char * getenv JPP((const char * name));
  51. #endif
  52.  
  53. #ifdef NEED_FAR_POINTERS
  54.  
  55. #ifdef __TURBOC__
  56. /* These definitions work for Borland C (Turbo C) */
  57. #include <alloc.h>        /* need farmalloc(), farfree() */
  58. #define far_malloc(x)    farmalloc(x)
  59. #define far_free(x)    farfree(x)
  60. #else
  61. /* These definitions work for Microsoft C and compatible compilers */
  62. #include <malloc.h>        /* need _fmalloc(), _ffree() */
  63. #define far_malloc(x)    _fmalloc(x)
  64. #define far_free(x)    _ffree(x)
  65. #endif
  66.  
  67. #else /* not NEED_FAR_POINTERS */
  68.  
  69. #define far_malloc(x)    malloc(x)
  70. #define far_free(x)    free(x)
  71.  
  72. #endif /* NEED_FAR_POINTERS */
  73.  
  74. #ifdef DONT_USE_B_MODE        /* define mode parameters for fopen() */
  75. #define READ_BINARY    "r"
  76. #else
  77. #define READ_BINARY    "rb"
  78. #endif
  79.  
  80. #if MAX_ALLOC_CHUNK >= 65535L    /* make sure jconfig.h got this right */
  81.   MAX_ALLOC_CHUNK should be less than 64K. /* deliberate syntax error */
  82. #endif
  83.  
  84.  
  85. /*
  86.  * Declarations for assembly-language support routines (see jmemdosa.asm).
  87.  *
  88.  * The functions are declared "far" as are all pointer arguments;
  89.  * this ensures the assembly source code will work regardless of the
  90.  * compiler memory model.  We assume "short" is 16 bits, "long" is 32.
  91.  */
  92.  
  93. typedef void far * XMSDRIVER;    /* actually a pointer to code */
  94. typedef struct {        /* registers for calling XMS driver */
  95.     unsigned short ax, dx, bx;
  96.     void far * ds_si;
  97.       } XMScontext;
  98. typedef struct {        /* registers for calling EMS driver */
  99.     unsigned short ax, dx, bx;
  100.     void far * ds_si;
  101.       } EMScontext;
  102.  
  103. EXTERN short far jdos_open JPP((short far * handle, char far * filename));
  104. EXTERN short far jdos_close JPP((short handle));
  105. EXTERN short far jdos_seek JPP((short handle, long offset));
  106. EXTERN short far jdos_read JPP((short handle, void far * buffer,
  107.                 unsigned short count));
  108. EXTERN short far jdos_write JPP((short handle, void far * buffer,
  109.                  unsigned short count));
  110. EXTERN void far jxms_getdriver JPP((XMSDRIVER far *));
  111. EXTERN void far jxms_calldriver JPP((XMSDRIVER, XMScontext far *));
  112. EXTERN short far jems_available JPP((void));
  113. EXTERN void far jems_calldriver JPP((EMScontext far *));
  114.  
  115.  
  116. /*
  117.  * Selection of a file name for a temporary file.
  118.  * This is highly system-dependent, and you may want to customize it.
  119.  */
  120.  
  121. static int next_file_num;    /* to distinguish among several temp files */
  122.  
  123. LOCAL void
  124. select_file_name (char * fname)
  125. {
  126.   const char * env;
  127.   char * ptr;
  128.   FILE * tfile;
  129.  
  130.   /* Keep generating file names till we find one that's not in use */
  131.   for (;;) {
  132.     /* Get temp directory name from environment TMP or TEMP variable;
  133.      * if none, use "."
  134.      */
  135.     if ((env = (const char *) getenv("TMP")) == NULL)
  136.       if ((env = (const char *) getenv("TEMP")) == NULL)
  137.     env = ".";
  138.     if (*env == '\0')        /* null string means "." */
  139.       env = ".";
  140.     ptr = fname;        /* copy name to fname */
  141.     while (*env != '\0')
  142.       *ptr++ = *env++;
  143.     if (ptr[-1] != '\\' && ptr[-1] != '/')
  144.       *ptr++ = '\\';        /* append backslash if not in env variable */
  145.     /* Append a suitable file name */
  146.     next_file_num++;        /* advance counter */
  147.     sprintf(ptr, "JPG%03d.TMP", next_file_num);
  148.     /* Probe to see if file name is already in use */
  149.     if ((tfile = fopen(fname, READ_BINARY)) == NULL)
  150.       break;
  151.     fclose(tfile);        /* oops, it's there; close tfile & try again */
  152.   }
  153. }
  154.  
  155.  
  156. /*
  157.  * Near-memory allocation and freeing are controlled by the regular library
  158.  * routines malloc() and free().
  159.  */
  160.  
  161. GLOBAL void *
  162. jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
  163. {
  164.   return (void *) malloc(sizeofobject);
  165. }
  166.  
  167. GLOBAL void
  168. jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
  169. {
  170.   free(object);
  171. }
  172.  
  173.  
  174. /*
  175.  * "Large" objects are allocated in far memory, if possible
  176.  */
  177.  
  178. GLOBAL void FAR *
  179. jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
  180. {
  181.   return (void FAR *) far_malloc(sizeofobject);
  182. }
  183.  
  184. GLOBAL void
  185. jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
  186. {
  187.   far_free(object);
  188. }
  189.  
  190.  
  191. /*
  192.  * This routine computes the total memory space available for allocation.
  193.  * It's impossible to do this in a portable way; our current solution is
  194.  * to make the user tell us (with a default value set at compile time).
  195.  * If you can actually get the available space, it's a good idea to subtract
  196.  * a slop factor of 5% or so.
  197.  */
  198.  
  199. #ifndef DEFAULT_MAX_MEM        /* so can override from makefile */
  200. #define DEFAULT_MAX_MEM        300000L /* for total usage about 450K */
  201. #endif
  202.  
  203. GLOBAL long
  204. jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
  205.             long max_bytes_needed, long already_allocated)
  206. {
  207.   return cinfo->mem->max_memory_to_use - already_allocated;
  208. }
  209.  
  210.  
  211. /*
  212.  * Backing store (temporary file) management.
  213.  * Backing store objects are only used when the value returned by
  214.  * jpeg_mem_available is less than the total space needed.  You can dispense
  215.  * with these routines if you have plenty of virtual memory; see jmemnobs.c.
  216.  */
  217.  
  218. /*
  219.  * For MS-DOS we support three types of backing storage:
  220.  *   1. Conventional DOS files.  We access these by direct DOS calls rather
  221.  *      than via the stdio package.  This provides a bit better performance,
  222.  *      but the real reason is that the buffers to be read or written are FAR.
  223.  *      The stdio library for small-data memory models can't cope with that.
  224.  *   2. Extended memory, accessed per the XMS V2.0 specification.
  225.  *   3. Expanded memory, accessed per the LIM/EMS 4.0 specification.
  226.  * You'll need copies of those specs to make sense of the related code.
  227.  * The specs are available by Internet FTP from the SIMTEL archives 
  228.  * (oak.oakland.edu and its various mirror sites).  See files
  229.  * pub/msdos/microsoft/xms20.arc and pub/msdos/info/limems41.zip.
  230.  */
  231.  
  232.  
  233. /*
  234.  * Access methods for a DOS file.
  235.  */
  236.  
  237.  
  238. METHODDEF void
  239. read_file_store (j_common_ptr cinfo, backing_store_ptr info,
  240.          void FAR * buffer_address,
  241.          long file_offset, long byte_count)
  242. {
  243.   if (jdos_seek(info->handle.file_handle, file_offset))
  244.     ERREXIT(cinfo, JERR_TFILE_SEEK);
  245.   /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
  246.   if (byte_count > 65535L)    /* safety check */
  247.     ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
  248.   if (jdos_read(info->handle.file_handle, buffer_address,
  249.         (unsigned short) byte_count))
  250.     ERREXIT(cinfo, JERR_TFILE_READ);
  251. }
  252.  
  253.  
  254. METHODDEF void
  255. write_file_store (j_common_ptr cinfo, backing_store_ptr info,
  256.           void FAR * buffer_address,
  257.           long file_offset, long byte_count)
  258. {
  259.   if (jdos_seek(info->handle.file_handle, file_offset))
  260.     ERREXIT(cinfo, JERR_TFILE_SEEK);
  261.   /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */
  262.   if (byte_count > 65535L)    /* safety check */
  263.     ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
  264.   if (jdos_write(info->handle.file_handle, buffer_address,
  265.          (unsigned short) byte_count))
  266.     ERREXIT(cinfo, JERR_TFILE_WRITE);
  267. }
  268.  
  269.  
  270. METHODDEF void
  271. close_file_store (j_common_ptr cinfo, backing_store_ptr info)
  272. {
  273.   jdos_close(info->handle.file_handle);    /* close the file */
  274.   remove(info->temp_name);    /* delete the file */
  275. /* If your system doesn't have remove(), try unlink() instead.
  276.  * remove() is the ANSI-standard name for this function, but
  277.  * unlink() was more common in pre-ANSI systems.
  278.  */
  279.   TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name);
  280. }
  281.  
  282.  
  283. LOCAL boolean
  284. open_file_store (j_common_ptr cinfo, backing_store_ptr info,
  285.          long total_bytes_needed)
  286. {
  287.   short handle;
  288.  
  289.   select_file_name(info->temp_name);
  290.   if (jdos_open((short far *) & handle, (char far *) info->temp_name)) {
  291.     /* might as well exit since jpeg_open_backing_store will fail anyway */
  292.     ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name);
  293.     return FALSE;
  294.   }
  295.   info->handle.file_handle = handle;
  296.   info->read_backing_store = read_file_store;
  297.   info->write_backing_store = write_file_store;
  298.   info->close_backing_store = close_file_store;
  299.   TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name);
  300.   return TRUE;            /* succeeded */
  301. }
  302.  
  303.  
  304. /*
  305.  * Access methods for extended memory.
  306.  */
  307.  
  308. #if XMS_SUPPORTED
  309.  
  310. static XMSDRIVER xms_driver;    /* saved address of XMS driver */
  311.  
  312. typedef union {            /* either long offset or real-mode pointer */
  313.     long offset;
  314.     void far * ptr;
  315.       } XMSPTR;
  316.  
  317. typedef struct {        /* XMS move specification structure */
  318.     long length;
  319.     XMSH src_handle;
  320.     XMSPTR src;
  321.     XMSH dst_handle;
  322.     XMSPTR dst;
  323.       } XMSspec;
  324.  
  325. #define ODD(X)    (((X) & 1L) != 0)
  326.  
  327.  
  328. METHODDEF void
  329. read_xms_store (j_common_ptr cinfo, backing_store_ptr info,
  330.         void FAR * buffer_address,
  331.         long file_offset, long byte_count)
  332. {
  333.   XMScontext ctx;
  334.   XMSspec spec;
  335.   char endbuffer[2];
  336.  
  337.   /* The XMS driver can't cope with an odd length, so handle the last byte
  338.    * specially if byte_count is odd.  We don't expect this to be common.
  339.    */
  340.  
  341.   spec.length = byte_count & (~ 1L);
  342.   spec.src_handle = info->handle.xms_handle;
  343.   spec.src.offset = file_offset;
  344.   spec.dst_handle = 0;
  345.   spec.dst.ptr = buffer_address;
  346.   
  347.   ctx.ds_si = (void far *) & spec;
  348.   ctx.ax = 0x0b00;        /* EMB move */
  349.   jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  350.   if (ctx.ax != 1)
  351.     ERREXIT(cinfo, JERR_XMS_READ);
  352.  
  353.   if (ODD(byte_count)) {
  354.     read_xms_store(cinfo, info, (void FAR *) endbuffer,
  355.            file_offset + byte_count - 1L, 2L);
  356.     ((char FAR *) buffer_address)[byte_count - 1L] = endbuffer[0];
  357.   }
  358. }
  359.  
  360.  
  361. METHODDEF void
  362. write_xms_store (j_common_ptr cinfo, backing_store_ptr info,
  363.          void FAR * buffer_address,
  364.          long file_offset, long byte_count)
  365. {
  366.   XMScontext ctx;
  367.   XMSspec spec;
  368.   char endbuffer[2];
  369.  
  370.   /* The XMS driver can't cope with an odd length, so handle the last byte
  371.    * specially if byte_count is odd.  We don't expect this to be common.
  372.    */
  373.  
  374.   spec.length = byte_count & (~ 1L);
  375.   spec.src_handle = 0;
  376.   spec.src.ptr = buffer_address;
  377.   spec.dst_handle = info->handle.xms_handle;
  378.   spec.dst.offset = file_offset;
  379.  
  380.   ctx.ds_si = (void far *) & spec;
  381.   ctx.ax = 0x0b00;        /* EMB move */
  382.   jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  383.   if (ctx.ax != 1)
  384.     ERREXIT(cinfo, JERR_XMS_WRITE);
  385.  
  386.   if (ODD(byte_count)) {
  387.     read_xms_store(cinfo, info, (void FAR *) endbuffer,
  388.            file_offset + byte_count - 1L, 2L);
  389.     endbuffer[0] = ((char FAR *) buffer_address)[byte_count - 1L];
  390.     write_xms_store(cinfo, info, (void FAR *) endbuffer,
  391.             file_offset + byte_count - 1L, 2L);
  392.   }
  393. }
  394.  
  395.  
  396. METHODDEF void
  397. close_xms_store (j_common_ptr cinfo, backing_store_ptr info)
  398. {
  399.   XMScontext ctx;
  400.  
  401.   ctx.dx = info->handle.xms_handle;
  402.   ctx.ax = 0x0a00;
  403.   jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  404.   TRACEMS1(cinfo, 1, JTRC_XMS_CLOSE, info->handle.xms_handle);
  405.   /* we ignore any error return from the driver */
  406. }
  407.  
  408.  
  409. LOCAL boolean
  410. open_xms_store (j_common_ptr cinfo, backing_store_ptr info,
  411.         long total_bytes_needed)
  412. {
  413.   XMScontext ctx;
  414.  
  415.   /* Get address of XMS driver */
  416.   jxms_getdriver((XMSDRIVER far *) & xms_driver);
  417.   if (xms_driver == NULL)
  418.     return FALSE;        /* no driver to be had */
  419.  
  420.   /* Get version number, must be >= 2.00 */
  421.   ctx.ax = 0x0000;
  422.   jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  423.   if (ctx.ax < (unsigned short) 0x0200)
  424.     return FALSE;
  425.  
  426.   /* Try to get space (expressed in kilobytes) */
  427.   ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10);
  428.   ctx.ax = 0x0900;
  429.   jxms_calldriver(xms_driver, (XMScontext far *) & ctx);
  430.   if (ctx.ax != 1)
  431.     return FALSE;
  432.  
  433.   /* Succeeded, save the handle and away we go */
  434.   info->handle.xms_handle = ctx.dx;
  435.   info->read_backing_store = read_xms_store;
  436.   info->write_backing_store = write_xms_store;
  437.   info->close_backing_store = close_xms_store;
  438.   TRACEMS1(cinfo, 1, JTRC_XMS_OPEN, ctx.dx);
  439.   return TRUE;            /* succeeded */
  440. }
  441.  
  442. #endif /* XMS_SUPPORTED */
  443.  
  444.  
  445. /*
  446.  * Access methods for expanded memory.
  447.  */
  448.  
  449. #if EMS_SUPPORTED
  450.  
  451. /* The EMS move specification structure requires word and long fields aligned
  452.  * at odd byte boundaries.  Some compilers will align struct fields at even
  453.  * byte boundaries.  While it's usually possible to force byte alignment,
  454.  * that causes an overall performance penalty and may pose problems in merging
  455.  * JPEG into a larger application.  Instead we accept some rather dirty code
  456.  * here.  Note this code would fail if the hardware did not allow odd-byte
  457.  * word & long accesses, but all 80x86 CPUs do.
  458.  */
  459.  
  460. typedef void far * EMSPTR;
  461.  
  462. typedef union {            /* EMS move specification structure */
  463.     long length;        /* It's easy to access first 4 bytes */
  464.     char bytes[18];        /* Misaligned fields in here! */
  465.       } EMSspec;
  466.  
  467. /* Macros for accessing misaligned fields */
  468. #define FIELD_AT(spec,offset,type)  (*((type *) &(spec.bytes[offset])))
  469. #define SRC_TYPE(spec)        FIELD_AT(spec,4,char)
  470. #define SRC_HANDLE(spec)    FIELD_AT(spec,5,EMSH)
  471. #define SRC_OFFSET(spec)    FIELD_AT(spec,7,unsigned short)
  472. #define SRC_PAGE(spec)        FIELD_AT(spec,9,unsigned short)
  473. #define SRC_PTR(spec)        FIELD_AT(spec,7,EMSPTR)
  474. #define DST_TYPE(spec)        FIELD_AT(spec,11,char)
  475. #define DST_HANDLE(spec)    FIELD_AT(spec,12,EMSH)
  476. #define DST_OFFSET(spec)    FIELD_AT(spec,14,unsigned short)
  477. #define DST_PAGE(spec)        FIELD_AT(spec,16,unsigned short)
  478. #define DST_PTR(spec)        FIELD_AT(spec,14,EMSPTR)
  479.  
  480. #define EMSPAGESIZE    16384L    /* gospel, see the EMS specs */
  481.  
  482. #define HIBYTE(W)  (((W) >> 8) & 0xFF)
  483. #define LOBYTE(W)  ((W) & 0xFF)
  484.  
  485.  
  486. METHODDEF void
  487. read_ems_store (j_common_ptr cinfo, backing_store_ptr info,
  488.         void FAR * buffer_address,
  489.         long file_offset, long byte_count)
  490. {
  491.   EMScontext ctx;
  492.   EMSspec spec;
  493.  
  494.   spec.length = byte_count;
  495.   SRC_TYPE(spec) = 1;
  496.   SRC_HANDLE(spec) = info->handle.ems_handle;
  497.   SRC_PAGE(spec)   = (unsigned short) (file_offset / EMSPAGESIZE);
  498.   SRC_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
  499.   DST_TYPE(spec) = 0;
  500.   DST_HANDLE(spec) = 0;
  501.   DST_PTR(spec)    = buffer_address;
  502.   
  503.   ctx.ds_si = (void far *) & spec;
  504.   ctx.ax = 0x5700;        /* move memory region */
  505.   jems_calldriver((EMScontext far *) & ctx);
  506.   if (HIBYTE(ctx.ax) != 0)
  507.     ERREXIT(cinfo, JERR_EMS_READ);
  508. }
  509.  
  510.  
  511. METHODDEF void
  512. write_ems_store (j_common_ptr cinfo, backing_store_ptr info,
  513.          void FAR * buffer_address,
  514.          long file_offset, long byte_count)
  515. {
  516.   EMScontext ctx;
  517.   EMSspec spec;
  518.  
  519.   spec.length = byte_count;
  520.   SRC_TYPE(spec) = 0;
  521.   SRC_HANDLE(spec) = 0;
  522.   SRC_PTR(spec)    = buffer_address;
  523.   DST_TYPE(spec) = 1;
  524.   DST_HANDLE(spec) = info->handle.ems_handle;
  525.   DST_PAGE(spec)   = (unsigned short) (file_offset / EMSPAGESIZE);
  526.   DST_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE);
  527.   
  528.   ctx.ds_si = (void far *) & spec;
  529.   ctx.ax = 0x5700;        /* move memory region */
  530.   jems_calldriver((EMScontext far *) & ctx);
  531.   if (HIBYTE(ctx.ax) != 0)
  532.     ERREXIT(cinfo, JERR_EMS_WRITE);
  533. }
  534.  
  535.  
  536. METHODDEF void
  537. close_ems_store (j_common_ptr cinfo, backing_store_ptr info)
  538. {
  539.   EMScontext ctx;
  540.  
  541.   ctx.ax = 0x4500;
  542.   ctx.dx = info->handle.ems_handle;
  543.   jems_calldriver((EMScontext far *) & ctx);
  544.   TRACEMS1(cinfo, 1, JTRC_EMS_CLOSE, info->handle.ems_handle);
  545.   /* we ignore any error return from the driver */
  546. }
  547.  
  548.  
  549. LOCAL boolean
  550. open_ems_store (j_common_ptr cinfo, backing_store_ptr info,
  551.         long total_bytes_needed)
  552. {
  553.   EMScontext ctx;
  554.  
  555.   /* Is EMS driver there? */
  556.   if (! jems_available())
  557.     return FALSE;
  558.  
  559.   /* Get status, make sure EMS is OK */
  560.   ctx.ax = 0x4000;
  561.   jems_calldriver((EMScontext far *) & ctx);
  562.   if (HIBYTE(ctx.ax) != 0)
  563.     return FALSE;
  564.  
  565.   /* Get version, must be >= 4.0 */
  566.   ctx.ax = 0x4600;
  567.   jems_calldriver((EMScontext far *) & ctx);
  568.   if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40)
  569.     return FALSE;
  570.  
  571.   /* Try to allocate requested space */
  572.   ctx.ax = 0x4300;
  573.   ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE);
  574.   jems_calldriver((EMScontext far *) & ctx);
  575.   if (HIBYTE(ctx.ax) != 0)
  576.     return FALSE;
  577.  
  578.   /* Succeeded, save the handle and away we go */
  579.   info->handle.ems_handle = ctx.dx;
  580.   info->read_backing_store = read_ems_store;
  581.   info->write_backing_store = write_ems_store;
  582.   info->close_backing_store = close_ems_store;
  583.   TRACEMS1(cinfo, 1, JTRC_EMS_OPEN, ctx.dx);
  584.   return TRUE;            /* succeeded */
  585. }
  586.  
  587. #endif /* EMS_SUPPORTED */
  588.  
  589.  
  590. /*
  591.  * Initial opening of a backing-store object.
  592.  */
  593.  
  594. GLOBAL void
  595. jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
  596.              long total_bytes_needed)
  597. {
  598.   /* Try extended memory, then expanded memory, then regular file. */
  599. #if XMS_SUPPORTED
  600.   if (open_xms_store(cinfo, info, total_bytes_needed))
  601.     return;
  602. #endif
  603. #if EMS_SUPPORTED
  604.   if (open_ems_store(cinfo, info, total_bytes_needed))
  605.     return;
  606. #endif
  607.   if (open_file_store(cinfo, info, total_bytes_needed))
  608.     return;
  609.   ERREXITS(cinfo, JERR_TFILE_CREATE, "");
  610. }
  611.  
  612.  
  613. /*
  614.  * These routines take care of any system-dependent initialization and
  615.  * cleanup required.
  616.  */
  617.  
  618. GLOBAL long
  619. jpeg_mem_init (j_common_ptr cinfo)
  620. {
  621.   next_file_num = 0;        /* initialize temp file name generator */
  622.   return DEFAULT_MAX_MEM;    /* default for max_memory_to_use */
  623. }
  624.  
  625. GLOBAL void
  626. jpeg_mem_term (j_common_ptr cinfo)
  627. {
  628.   /* Microsoft C, at least in v6.00A, will not successfully reclaim freed
  629.    * blocks of size > 32Kbytes unless we give it a kick in the rear, like so:
  630.    */
  631. #ifdef NEED_FHEAPMIN
  632.   _fheapmin();
  633. #endif
  634. }
  635.